\documentclass[12pt]{article}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
\usepackage[greek,francais]{babel}
\usepackage{amsthm}
\usepackage{lmodern}
\usepackage{amsmath}
\usepackage{amsfonts}
\usepackage{pict2e}
\usepackage{listing}
\usepackage{url}
\usepackage{pdfpages}
\usepackage{hyperref}
\usepackage{listings}
\usepackage[DIV15]{typearea}
\usepackage{fancyhdr}

\title{}
\author{LYAZIDI Reda}
\date{\today}
\begin{document}
%%%% debut macro %%%%
\newenvironment{changemargin}[2]{\begin{list}{}{%
\setlength{\topsep}{0pt}%
\setlength{\leftmargin}{0pt}%
\setlength{\rightmargin}{0pt}%
\setlength{\listparindent}{\parindent}%
\setlength{\itemindent}{\parindent}%
\setlength{\parsep}{0pt plus 1pt}%
\addtolength{\leftmargin}{#1}%
\addtolength{\rightmargin}{#2}%
}\item }{\end{list}}
%%%% fin macro %%%%
\bibliographystyle{unsrt}
%\tableofcontents
%\addtolength{\hoffset}{-5cm}
%\addtolength{\textwidth}{-1cm} 
%\addtolength{\voffset}{5cm}
%\addtolength{\textheight}{-0.6cm}
\pagestyle{fancy}
\lfoot{
\addtolength{\hoffset}{15cm}
%\begin{changemargin}{-5cm}{-5cm}
\includegraphics[scale=0.9]{images/cortixfooter}
%\end{changemargin}
}
\includegraphics[scale=0.5]{images/logobdx1}
\hspace*{10cm}
\includegraphics[scale=0.5]{images/logocortix} \\
\begin{center}
\vspace*{1cm}
\LARGE{\textbf{Créateur de sites web clés en mains, pour tout type
d'entreprise}}\\
%\includegraphics[scale=1]{images/vague1}
%Ceci est un commentaire et en aucun cas ne figurera sur le pdf généré.
\vspace*{2cm}

 \normalsize{Stage} de Master 1 Informatique réalisé par\\
Reda LYAZIDI \\
du 2 mai au 31 août 2012 \\
au sein de l'entreprise Cortix à Mérignac, Gironde. \\

\vspace*{2cm}
Maître de stage : Florent CHOLET
\end{center}
\newpage
\tableofcontents
\newpage
\vspace*{5cm}

\begin{center} \large{\textbf{Remerciements}} \end{center}
Je remercie Monsieur Hassane HAMZA, Président et fondateur de Cortix, mon maître de stage Monsieur
Florent CHOLET, chef de Projet, Monsieur Emmanuel BARBE directeur des Systèmes d'Informations, Monsieur Michaël 
DAVANT, chef de projet, Monsieur Sylvain RASCAR, développeur et Messieurs Samuel DURAN et Philippe LACOUCHIE, 
responsables infrastructure et réseaux, de m'avoir accueilli au sein de l'entreprise durant ces quatre mois.
Leur soutien et leurs indications m'ont guidé, et m'ont permis d'avancer face aux problèmes rencontrés.\\
Je remercie également tous les membres du siège de leur accueil, de leur disponibilité \\ notamment pour répondre
à mes questions sur l'entreprise.

\newpage

%\begin{center} \large{\textbf{Introduction}} \end{center}
\section*{Introduction}
Afin de compléter ma formation et de découvrir le monde de l'entreprise j'ai décidé 
de réaliser un stage durant l'été entre le Master 1 et le Master 2. \\
Mon stage d'été s'est déroulé du 2 mai au 31 août 2012 à Mérignac, au sein de la société \textbf{Cortix},
sous la responsabilité de Monsieur Florent CHOLET, chef de projet.\\
De part son envergure la société \textbf{Cortix}, se doit de posséder 
sa propre DSI(Direction des Services  d'Informations), le rôle de la DSI est de gérer les réseaux administratifs,
d'administrer les bases de données et \textbf{d'anticiper les évolutions} de l'entreprise en fonction de sa stratégie.
Dans le but d'évoluer, la DSI envisageait de migrer une partie de ses applications vers 
\textit{\og google apps for business\fg} (outils de bureautique web, moteur d'application), \\
ainsi la nécessité pour la DSI d'évaluer les différentes technologies qu'offrent \textbf{Google}. \\
Mon stage avait pour optique de créer et des tester des prototypes d'applications de gestion
(à titre d'exemple : gestion de notes de frais, demandes de congés) à partir de l'app engine en \textbf{Python}, afin 
d'évaluer la  fiabilité et l'efficacité de ces services, ce travail couvre les domaines de la programmation web et le 
\textit{cloud computing}.\\
La première partie du rapport présente la société \textbf{Cortix}, son organisation, ainsi que sa structure et
ses activités, puis en seconde partie le lieu et les conditions de travail, puis en troisième partie le travail 
réalisé.

\newpage

\section{Cortix, agence web spécialisée \\ en solutions informatiques}
\subsection{Création et évolution}
\subsubsection{Une fulgurante ascension}
Fondée à Bordeaux en 1999 par Monsieur Hassane HAMZA, Cortix est spécialisée dans l'offre de site internet
pour les entreprises (création, hébergement, référencement et maintenance), en particulier pour les petites et 
moyennes entreprises. Ce qui commença par une petite entreprise (moins de dix employés) devint en quelques années
l'un des leaders de la création du sites web en France. Son \textbf{entrée en Bourse en Décembre 2007} lui a permis
de lever des fonds pour se développer davantage, afin de répondre à la conjoncture, \textbf{Cortix} s'adapte 
avec plus de flexibilité dans son plan de développement  et de recrutement, une meilleure productivité et une plus
grande attention à la fidélisation des clients actuels d'ailleurs entre 2007 et 2008 le chiffre d'affaire a doublé 
passant de 14,3 M\textgreek{\euro} à 28,3 M\textgreek{\euro}, cette article \cite{SDO11-11-2011} prouve cette
fulgurant ascension face à cette forte  croissance, \textbf{Cortix} a du évoluer afin d'acquérir une Direction de la 
Relation Client renforcée ainsi que des 
services de supports structurés
(Marketing, DSI,DRH,DAF ...), afin de renforcer son activité.Cependant suite à la crise financière comme le confirme 
ce même article, \og la 
société avait été confronté à un contexte social difficile, et à une montée
en flèche des défaillances de ses clients \fg 

\subsubsection{Un renouveau à travers un contexte difficile}
Suite à ce déclin la société réagit, grâce à l'investissement l'annuaire \textbf{3999} devenu actionnaire (cf 
\cite{SDO11-11-2011}) en 2011, \textbf{Cortix} crée cette même année le 29 août la marque \textbf{Elliweb}, proposant 
de nouvelles offres à des prix inférieurs et des contrats à durée plus courte, 4 à 5 ans contrat de \textbf{Cortix} 
classique contre 12 à 24 mois pour les contrats \textbf{Elliweb}, c'est pour cette raison que certains sites
possède ce logo :
\includegraphics[scale=0.25]{images/logoelliweb}
,permettant ainsi de renforcer son activité.

\subsection{Son Activité}
\begin{itemize}
\item[] \textbf{\textit{L'offre internet \og personnalisée \fg} aux entreprises}. \\
\end{itemize}
Depuis quelques années, qui plus est actuellement les entreprises (PME,TPE,Artisans,Commerçants,...) ont plus que
jamais besoin d'outils numériques performants pour "booster" leurs ventes et faire valoir leur image.
En effet, le développement de leur activité passe énormément par le NET, \textbf{Cortix} répond avec simplicité à 
cette demande. Elle spécialisée dans l'offre globale sur mesure \og clés en mains \fg .
\textbf{Sa démarche} consiste grâce à son centre d'appel situé à Tunis (cf \cite{SDO28/10/2010}) de démarcher
des clients, puis des commerciaux partent pour conclure des clients (nouveau ou ancien) puis de leur 
proposer l'une des offres du catalogue de \textbf{Cortix} ou du pack \textbf{Elliweb} depuis fin 2011. En effet les 
VRP sont divisés en deux catégories, ceux allant démarcher de nouveaux clients et ceux proposant des renouvellements 
ou des nouveaux contrats à d'ancien clients. Cette démarche est basée sur le système de \og One Shot\fg, en effet en 
\textbf{UNE} prestation le VRP part avec un contrat qui est remis à son agence puis au siège pour l'exécution
des contrats.
%Actuellement une S.A au capital de 295 000 \textgreek{\euro}
\newpage
\subsection{Structure et organisation}
\subsubsection{Structure}
\textbf{Cortix} est composée de plusieurs agences à travers l'Europe (cf annexe 1). Ces agences sont composées
de commerciaux et d'un directeur d'agence, le siège se trouve à Mérignac, ce bâtiment regroupe le siège et
l'agence de Bordeaux. Bien que cette agence se trouve au sein du siège son fonctionnement reste similaire à celle
des autres agences. \textbf{Proxitel} est le centre d'appel de \textbf{Cortix} située à Tunis, à Tunis se trouve 
une équipe pour le centre d'appel, qui va démarcher des clients, ou traiter par téléphone des éventuelles litiges ou
de simples demande de modifications, se trouve également une équipe de développeur et de webmasters pour traiter à la
fois la création de sites et le développement d'application nécessaire au bon fonctionnement de l'entreprise, et au 
sein du siège se trouve les services essentiels à la plupart des entreprises (DAF,DRH,service client,Comptabilité, 
DSI...). Voici la structure de la DSI ainsi que c'est membre: \\

\includegraphics[scale=1]{images/DSIhierarchy}
\newpage
\subsubsection{Organisation}
Lorsqu'une demande arrive au siège elle traitée, au siège qui réalise le cahier des charges signé par le client et le 
VRP, (achat du nom de domaine, choix du template, ...), ensuite le cahier des charges et envoyé à Tunis, puis une
une fois le site terminé une vérification au siège est effectué par le service client.
Le schéma suivant résume ce processus:

\includegraphics[scale= 0.5]{images/suividedossier}

Les sites sont hébergés à 99\% sur les serveurs de l'entreprise \textbf{Khéops}, 
\includegraphics[scale= 0.25]{images/Kheops_createurTransparent}
le 1\% restant est hébergé sur des serveurs privés.
En effet, aucun des sites des clients de \textbf{Cortix} ne sont hébergés au sein du siège,
les serveurs du siège hébergent des applications créées et maintenues par la DSI. 

Voici un exemple de sites réalisés par \textbf{Cortix}: \\
%\begin{changemargin}{-4cm}{-1cm}
\newpage
\url{www.ingeflux-dgci.com}\\
\includegraphics[scale=0.4]{images/ingeflux-dgci}\\

et deux autres en annexes. \\

\newpage
\section{Lieu de travail}%1.-
%
\subsection{Analyse du service}
Comme il a été précisé précédemment le rôle de ce service et d'anticiper les 
évolutions de l'entreprise, responsable de l'environnement numérique de 
travail et de diriger des projets visant à la création d'outils permettant de 
faciliter le travail des membres de l'entreprise. \\
Afin d'anticiper les besoins, et faciliter le travail de chacun, la DSI a mis 
en place 3 outils devenus indispensables pour les services concernés.
\begin{enumerate}

\item \textbf{\underline{RAC} (Rapport d'Activité Commerciale)} \\
Outil de reporting des activités commerciales, il permet à un directeur 
d'agence de piloter
son équipe de VRP en activant/désactivant un ou plusieurs VRP, à chaque 
connexion le directeur d'agence
doit valider son équipe, le RAC permet aussi aux VRP de saisir leur rendez-
vous et de consulter leur agenda.
De plus la force de vente (PROXITEL, le centre d'appel), peut à tout moment 
rajouter un rendez-vous dans l'agenda
d'un VRP suite à une prospection téléphonique réussite.

\item \textbf{Le gestionnaire des \underline{NDD}} (Nom De Domaine)
Cette application permet de mettre en ligne un site web, ou l'inverse. Son 
rôle est d'offrir une interface ergonomique 
et simple afin d'administrer les noms de domaines, elle est utilisée au sein 
même de la DSI, mais aussi par PROXITEL 
et le service client.

\item \textbf{\underline{CRM} (Customer Relationship Management = Gestion de 
la Relation Client)} \\
La mise en place de ce logiciel a permis et permet un accompagnement des plus 
précis afin d'assurer une politique
de fidélisation d'une clientèle croissante. Le CRM permet d'avoir un suivi des 
mensualités, l'état des sites (en 
ligne, hors-ligne, modification en cours ...), les clients( actifs, changement 
de contrats, résiliés ...), ainsi
n'importe quelle service en particulier le service client peut à tout moment 
savoir l'état et le déroulement 
des demandes. De plus, le CRM enregistre les demandes de modifications et les 
webmasters les signalent une fois traitées.
\end{enumerate}

%2.-
%
\subsection{Environnement de travail}
Pour les besoins de mon stage, un ordinateur m'a été attribué sous Windows 
XP,mon bureau se situé à l'open-space de la DSI. Mon emplacement m'offrait 
l'avantage de pouvoir de solliciter à tout moment conseil auprès d'un membre 
de la DSI, en particulier mon maître de stage, étant donné que je me trouvais 
dans une agence web mon ordinateur avait de base installer plusieurs 
navigateurs web (les principaux), au niveau des logiciels à utiliser pour 
travailler je n'avais aucune consigne particulière, ainsi j'ai débuté avec un 
simple éditeur de texte tel que NotePad++. Mes missions étaient uniquement du 
domaine de la programmation web.
Évidemment un compte mail pro m'a été attribué, j'en possédais deux, l'une 
avec le domaine \textbf{cortix} et l'autre avec le domaine \textbf{elliweb}. 
Seul quelques membres de la DSI possédaient une adresse de type elliweb, tous 
les autres membres de l'entreprise utilisé leur adresse cortix accessible via 
le logiciel de messagerie Microsoft Outlook. Le domaine \textit{elliweb}
(en l'honneur de la marque) fut créé par mon maître de stage M.CHOLET auprès 
de Google, donc elliweb est un sous-
domaine de \textbf{gmail}, ainsi lors d'une connexion à gmail j'utilisais mon 
adresse pro elliweb et avait ainsi accès à mes mails de la même manière que je 
l'ai avec mon adresse gmail personnelle. De plus je profitais de tous les 
services de Google( Google docs, Google drive, Google calendar ...). Les 
développeurs ainsi que les chefs de projets utilisent le gestionnaire de 
version Subversion que j'ai déjà utilisé par la suite et dont je connaissais 
son fonctionnement de part ma formation. Les outils utilisés furent diverses, 
notamment les IDE Eclipse et NetBeans, puis pour le développement web 
l'incontournable "Firebug". \\
C'est dans ce contexte que je me suis vu confier ma première mission, étant
de tester et d'évaluer les Google App Engine(GAE), suivi d'une mission très 
succincte la mise en place d'une base de connaissance via le CMS Drupal, puis
la réalisation d'un gestionnaire de congés en php en utilisant le célèbre 
framework Symfony.

\section{Le travail réalisé}
\subsection{Google App Engine(=GAE)}
\includegraphics[scale=0.25]{images/logoGAE}
Cette mission était un travail de recherche pour la DSI car aucun de 
ses membres n'avait étudié le sujet, mon maître de stage m'expliqua 
l'utilisation des services de Google par la DSI et le but recherché.
L'objectif était d'évaluer le potentiel des GAE, à partir de ce lien 
\cite{GAE} je commençais ma découverte de l'app engine.
\subsubsection{Description et Caractéristiques}
Mis en place en Avril 2008, la dernière version est la 1.7.1 sortie le 21 août
de cette année(soit 10 jours avant la fin de mon stage),\\ (cf 
\url{https://developers.google.com/appengine/downloads}), ce service proposé 
par Google offre une plate-forme d'hébergement d'applications web sur les 
serveurs de Google. Le principe est de façon concise et très simple avoir son 
application (ou plus) s'éxécutant directement sur les serveurs de Google. 
Voici le "Hello World" sur l'app engine Python : 
\begin{verbatim}
import webapp2

class MainPage(webapp2.RequestHandler):
  def get(self):
      self.response.headers['Content-Type'] = 'text/plain'
      self.response.write('Hello, World!')

app = webapp2.WSGIApplication([('/', MainPage)],
                              debug=True)
\end{verbatim}
Le résultat est équivalent à un simple echo 'Hello, World!', en php par 
exemple,
à la grande différence que ce script est exécuté sur les serveurs de Google.
Il n'y a pour l'instant aucun chiffre officiel, pour cette année, mais les 
serveurs du géant américain représente environ 2\% des serveurs mondiaux,
ainsi Google cherche a profité de sa position de leader, car en effet ce 
service n'est pas totalement gratuit, il l'est jusqu'à un certain point, si 
l'application  utilise un grand nombre de ressources cela va devenir 
nécessaire de payer. L'annexe C montre le tableau de bord de l'app engine,
accessible sur le site \url{https://appengine.google.com}
Ce système remet les compteurs à zéro toutes les 24H, soit en ce moment à 9h 
du matin. Toutefois ce service est par défaut gratuit, par exemple on a le 
droit à 100 envois d'emails toutes les 24H, via le tableau de bord il est
possible de passer en mode payant, le principe est simple, on ne paye que ce 
qu'on utilise en surplus, ce n'est pas du tout un système de forfait 
contrairement à \textbf{Amazon}. Si il y a dépassement de quota et 
impossibilité de prélever, le  système lève une exception pouvant être gérée 
comme n'importe quelle exception.
De plus lorsque l'on autorise les prélèvements il est possible de fixer par 
app engine un budget maximum, ainsi le serveur lèvera la même exception que si 
l'on dépasse le quota qu'en mode gratuit, ce système de budget est très 
pratique car il permet de contrôler les ressources, notamment éviter de trop 
grandes pertes suite à un script utilisant trop de ressources qu'il n'en 
devrait (boucle infinie ... par exemple). \\
\begin{itemize}
\item[] \textbf{Démarrer avec l'app engine}
\end{itemize}
Tout d'abord il faut installer la SDK de Google, puis créer un compte app 
engine.
Le procédé se fait à travers un compte gmail, il faut donnée un numéro de 
portable puis un sms est envoyé contenant un numéro d'activation, par défaut 
on a le droit à \textbf{10} app engine par numéro de téléphone.
\begin{itemize}
\item[] \textbf{L'environnement de travail}
\end{itemize}
L'environnement est assez indépendant du système d'exploitation, j'ai 
d'ailleurs tester chez moi sous Linux et je n'ai rencontré aucune différence 
notable. À ses débuts l'app engine n'était uniquement qu'en Python, puis un an 
plus tard soit en Avril 2009 le support de Java est intégré, et depuis peu
le support du Go (langage de Google) est arrivé mais il est encore au stade
expérimental, c'est d'ailleurs pour cette raison que je ne me suis intéressé
à l'app engine Go. Le site des GAE offre un tutoriel pour démarrer, à noter
qu'en Java l'on est très vite orienté à utiliser l'IDE Eclipse et son plug-in
GAE, contrairement à Python ou le plug-in pour PyDev (plug-in pour Eclipse 
permettant de bénéficier d'un IDE pour les projets en Python) n'est que 
suggéré en annexe. \\
Un projet app engine est composé d'au moins de \textbf{deux} fichiers, un
fichier de code dans le langage choisi et du fichier de configuration de base
app.yml. Il est à noter que si l'on décide de réaliser une app engine en 
Python ou en Go les fichiers de configurations doivent être en 
YAML\up{\textbf{*}} avec l'extension .yml, alors que si c'est en Java ça sera
de l' XML\up{\textbf{*}}. Dans les deux cas les informations contenues dans 
ce(s) fichiers seront similaires. Je vais décrire les principe de base de la 
GAE, comme je l'ai traitée en Python je citerai des fichiers en .yml, mais en
Java les noms sont les mêmes mais avec l'extension .xml à la place.
Le fichier incontournable est le app.yml, c'est dans ce fichier qu'est stocké
le langage utilisé et sa version ,pour l'app engine Python seules les 
versions 2.5 et 2.7 sont possibles, le passage de 2.5 à 2.7 offre la 
possibilité d'envoi de requêtes simultanées, donc grâce à du multi-threading.
Cependant à l'instant où il est autorisé d'envoyer des mails, le multi-
threading doit être désactivé. Voici un fichier app.yaml :
\begin{verbatim}
#Ceci est un commentaire YAML
application: elliweb-test #id de l'application déterminée
# de sa création sur le site de l'app engine
version: 1 # pour l'instant il n'y a que la version 1 de l'app engine
runtime: python27
api_version: 1
threadsafe: false #le multi-threading

handlers:
#ceci permet de fixer des url à nos répertoires contenant les fichiers
# de complément de notre site web (css,js, images)
- url: /stylesheets
  static_dir: stylesheets
  
- url: /Template
  static_dir: Template

  
- url: /imcreatives
  static_dir: Template/imcreatives
  
- url: /css
  static_dir: Template/imcreatives/css
  
- url: /js
  static_dir: js
 
- url: /css
  static_dir: css
 
- url: /images
  static_dir: images
  
- url: /js
  static_dir: Template/imcreatives/js
  
- url: .*
  script: main.app
  
- url: /_ah/mail/.+
  script: handle_incoming_email.py
  login: admin

- url: /a/elliweb.fr
  script: do_openid_login.py

inbound_services:
- mail

libraries:
- name: webapp2
  version: "2.5.1"
  
- name: jinja2
  version: "2.6"
\end{verbatim}
D'autres fichiers peuvent être présent si leur fonctionnalité correspondante
est utilisée (mise en place de cron, blacklist ...). \\
Voici un "hello world" plus évolué :
\begin{verbatim}
import webapp2

from google.appengine.api import users

class MainPage(webapp2.RequestHandler):
    def get(self):
        user = users.get_current_user()

        if user:
            self.response.headers['Content-Type'] = 'text/plain'
            self.response.out.write('Hello, ' + user.nickname())
        else:
            self.redirect(users.create_login_url(self.request.uri))

app = webapp2.WSGIApplication([('/', MainPage)],
                              debug=True)
\end{verbatim}
Ce code affiche "hello" suivi du pseudo de l'utilisateur, sa grande 
particularité c'est que si il ne détecte aucun utilisateur connecté l'on est
automatiquement redirigé vers la page login de Google (i.e celle que tout le monde
utilise pour se connecter aux services de Google tel que gmail, Google 
drive...), de plus pour cette redirection automatique il n'y a rien à faire.
En effet ceci s'avère très pratique car dans le Dashboard mon maître de stage
a choisi de restreindre l'app engine que l'on a créé à des fins de tests, au
domaine elliweb, ainsi l'on était automatiquement rediriger vers non pas la 
page d'authentification de Google mais celle d'elliweb,c'est une page 
similaire excepté que dans le formulaire, le champ de texte correspondant au
mail n'accepte que le pseudo et il rajoute lui-même le domaine elliweb.fr,
par conséquent l'app engine devenait restreinte \textbf{uniquement} au domaine
elliweb. 
\begin{itemize}
\item[] \textbf{Lancer et tester son application}
\end{itemize}
Tout d'abord, il suffit d’exécuter cette commande Python dans un terminal :\\
\textit{google\_appengine/dev\_appserver.py helloworld/}\\
Il suffit d'entrer dans votre navigateur : \url{http://localhost:8080/} afin
de tester l'application en local, évidemment la redirection vers la page
d'authentification est factice, ici on ne teste que des bugs classiques ou des
erreurs de syntaxe, il faut ensuite déployer l'application à travers ce 
script\\ \textit{appcfg.py update helloworld/}, là l'application se trouve
à l'url : \url{http://id.appspot.com/} où "id" est le nom de l'application
qui a été choisi au moment de sa création et précisé dans le fichier app.yml
à la balise "application". Afin de faciliter le travail des développeurs,
un lanceur d'application Google app Engine pour Python uniquement a été créé. 
\\
\includegraphics[scale=1]{images/AppEngineLauncher}\\
Ce lanceur permet de réaliser les deux commandes précédents via une interface
intuitive, pour le configurer il suffit juste de lui donner le chemin de 
l'éxécutable Python et du répertoire de la SDK app engine. \\
J'ai par la suite utilisé ce lanceur simplifiant le travail. \\

Toutefois ceci reste limité, car écrire du code html directement en
paramètre de la méthode " self.response.out.write" n'est pas du tout commode
et cela ne respecterait pas le système MVC\up{\textbf{*}}.
\begin{verbatim}
import jinja2
import os

jinja_environment = jinja2.Environment(
    loader=jinja2.FileSystemLoader(os.path.dirname(__file__)))
    
class MainPage(webapp2.RequestHandler):
    def get(self):
        guestbook_name=self.request.get('guestbook_name')
        greetings_query = Greeting.all().ancestor(
            guestbook_key(guestbook_name)).order('-date')
        greetings = greetings_query.fetch(10)

        if users.get_current_user():
            url = users.create_logout_url(self.request.uri)
            url_linktext = 'Logout'
        else:
            url = users.create_login_url(self.request.uri)
            url_linktext = 'Login'

        template_values = {
            'greetings': greetings,
            'url': url,
            'url_linktext': url_linktext,
        }

        template = jinja_environment.get_template('index.html')
        self.response.out.write(template.render(template_values))
\end{verbatim}
Ce code nous permet de charger un template 'index.html', voici son contenu :
\begin{verbatim}
<html>
  <body>
    {% for greeting in greetings %}
      {% if greeting.author %}
        <b>{{ greeting.author }}</b> wrote:
      {% else %}
        An anonymous person wrote:
      {% endif %}
      <blockquote>{{ greeting.content|escape }}</blockquote>
    {% endfor %}

    <form action="/sign" method="post">
      <div><textarea name="content" rows="3" cols="60"></textarea></div>
      <div><input type="submit" value="Sign Guestbook"></div>
    </form>

    <a href="{{ url }}">{{ url_linktext }}</a>

  </body>
</html>
\end{verbatim}
Le l	angage correspondant au code avec les notation "\{\% \%\}" ou "\{\{ \}\}"
est le langage du moteur de template de Jinja, une librairie de Python, celui
du Django (autre lib Python) est similaire, son fonctionnement est détaillé
plus loin à travers le moteur de template TWIG celui de \textbf{Symfony}, 
quant au Model :
\begin{verbatim}
class Greeting(db.Model):
  """Models an individual Guestbook entry with an author, content, and date."""
  author = db.StringProperty()
  content = db.StringProperty(multiline=True)
  date = db.DateTimeProperty(auto_now_add=True)
\end{verbatim}
Ceci est une \textbf{entité}, notion très importante: \\
Une entité est un objet qui a pour particularité de pouvoir se persister,
ce qui signifie écrire son contenu dans une base de données, pour résumer
une classe(Python,Java,Php,...) correspond à une table de base de données, 
et une instance (si elle est enregistrée)  d'une table 
correspondant à la classe de l'instance.\\
Le système de base de donnée "Datastore" est de type NoSql signifiant  
selon wikipédia: \\
\og Cette catégorie de produits fait le compromis d'abandonner certaines 
fonctionnalités classiques des SGBD relationnels au profit de la simplicité, 
la performance et une montée en charge (scalabilité) élevée. \fg
\cite{JDataStore}, cette article bien que parlant pour l'app engine Java
(quelque soit le langage les ressources utilisées fonctionnent de façon
similaire). Ceci nous amène aux avantages et aux inconvénients de la GAE.

\subsubsection{Avantages et Inconvénients}
\begin{itemize}
\item[] \textbf{Avantages}
\end{itemize}
L'avantage principal est que très facilement l'on peut lancer une application
sur un serveur sans avoir à devoir l'entretenir et l'administrer, ce qui
est un inconvénient pour les petits hébergeurs (cf \cite{avisGAE}), le 
système de paiement est pratique car on paye que ce que l'on consomme tout
en pouvant fixer un budget, contrairement à Amazon et Windows Azure utilisant
un système de forfait, donc si l'application est moins utilisée à un moment
la mensualité ne changera pas , la présence de la concurrence même non direct
permet d'éviter à Google d'être en situation de monopole et de pouvoir 
augmenter ses prix par exemple. Le système Datastore marche en instruction
atomique, et bien qu'une transaction puisse réaliser plusieurs requêtes si
l'une des requêtes retourne une erreur aucune n'est exécutée afin de conserver
la cohérence des données. \\
Cependant à l'instant où l'on souhaite réaliser une application un peu plus 
poussée l'on est tenté d'utiliser des librairies, des frameworks et cela pose 
quelques problèmes.

\begin{itemize}
\item[] \textbf{Inconvénients}
\end{itemize}
Le premier est trivial, une totale dépendance auprès de Google, s'il change
les règles ça peut poser des problèmes à l'entreprise ou à un particulier
( cf \cite{GAEtarif}). Bien que pour envoyer des mails cela soit facile,
le code permettant d'envoyer un mail :
\begin{verbatim}
message = mail.EmailMessage(sender="elliweb.fr Support <r.lyazidi@elliweb.fr>",
                            subject="Envoi de Mail via la GAE")

#message.to = "Florent Cholet <f.cholet@elliweb.fr>"
message.body = """
"""un message quelconque"""
"""

message.send()
\end{verbatim}
Évidemment le destinataire peut être une autre adresse mail qu'une adresse de
type gmail. En mode "free" la limite est de 100 emails par jour.
Le système de base de donnée étant complètement différent d'un système 
classique tel que MySql, une migration est opération délicate, il existe
un service MySql par Google pour les app engine mais il est payant de base.
En effet, le but rechercher par mon maître de stage était un gestionnaire des
congés, mais faire la migration de la liste de tous les employés de 
\textbf{Cortix} aurait été une opération délicate. \\
Le service client a demandé à la DSI la réalisation d'un site permettant la 
mise en place d'instruction de travail, le site devait permettre à chacun en
particulier au service client de pouvoir trouver facilement une IT pour faire
face à chaque situation. Mon maître de stage eu l'idée d'utiliser le 
CMS\up{\textbf{*}} open-source Drupal, je fus chargé de cette mission.
L'important c'est qu'avant cette mission mon app engine avait un temps de 
latence considérable, j'ai même demandé à des camarades qui eux avait  un
très bon débit chez eux de tester et ils m'ont confirmer cette latence alors
que mon application était minimaliste. Il s'agissait d'un forum, il fallait
être connecté avec une adresse elliweb.fr pour pouvoir poster, et après
la semaine durant laquelle je me suis consacré à l'application regroupant
les IT, en me reconnectant à mon app engine la latence avait disparu alors
que je n'avais pas du tout changer le code, ainsi j'ai appris qu'une mise à
jour avait eu lieu car il y a des problèmes avec les serveurs Europe de l'app
engine (cf \cite{GAEupdate}). De plus, pour en revenir à l'utilisation de
librairies ou de framework, en Java l'on parle de \textit{\og JEE dry\fg},
l'utilisation de ces outils n'est pas commode sous l'app engine car il faut
choisir la bonne version et même ceci il reste des problèmes 
d'incompatibilité. De plus ces mise à jours successives de l'app engine 
entraîne une perte de la rétro-compatibilité, des pertes sur des temps très 
courts. C'est pour cette raison et la difficulté de la migration des données
que mon maître de stage m'a donnée une autre mission un gestionnaire de congés
en php sous le framework\up{\textbf{*}} Symfony.

\subsection{Un gestionnaire de congés}
\subsection{Analyse des besoins}
À mon arrivée la DSI ne dispose pas d'application permettant de gérer les
congés de tous les employés, ce qui peut s'avérer utile entre le siège et
toutes les agences de \textbf{Cortix}. Afin de bien analyser les besoins,
mon,maître de stage m'a demandé d'essayer ce site 
\url{http://www.timeoffmanager.com/}. Ce site permet de gérer les congés de 
ses entreprises, en effet lorsque l'on s'inscrit le nom de l'entreprise est
demandé et l'on récupère son id sur le site, et le formulaire de la page 
d'authenfication demande en plus l'id de l'entreprise. Ceci est l'un des 
aspects dont je ne me suis inspiré car le but était d'avoir une application
pour l'entreprise. Évidemment ce service est payant mais offre une période
d'essai que j'ai utilisé avant de m'inspirer de son fonctionnement.
\begin{enumerate}
\item Stocker les utilisateurs tous en ayant une hiérarchie
\item Pouvoir poser des congés selon le nombre de jours travaillé tout en 
comptant les congés déjà pris
\item Pouvoir à travers la base de donnée réaliser toutes les requêtes 
nécessaires permettant d'obtenir des informations clés, comme qui est parti à
tel date,...
\item Offrir une interface simples et intuitives pour poser des congés,
les valider ou les rejeter
\item contrôler les actions selon les droits
\item l'application doit être flexible, notamment une interface pour les 
admins, permettant de rajouter/enlever des utilisateurs, accorder/enlever des
droits
\item la	 flexibilité comprend la possibilité pour un admin de rajouter/enlever
des types de demandes (Congés, RTT par défaut), aussi les états(par défaut,
en cours, validé et rejeté)
\item Séparer la gestion des congés par service (éviter que les responsables 
d'un service puissent accéder aux demandes d'un tout autre service)
\end{enumerate}
La sécurité est un besoin implicite. Afin de remplir tous ces besoins 
notamment la gestion des utilisateurs le choix a été porté d'utiliser le
framework \textbf{Symfony}.
\subsection{Symfony}
Ce framework a été créé car en Php les développeurs trouvaient qu'ils 
faisaient trop souvent la même chose, une société \textbf{Sensio} l'a 
développé pour ses propres besoins puis en Octobre 2005 l'a rendu public.
Le 28 juillet 2011 la version 2 est sortie, cassant la compatibilité avec
la version 1, pour les nombreux développeurs étant sur la première version
ils ont du s'adapter à la seconde, pour ma part j'ai directement appris cette
version. Le principale défaut d'un framework est le temps d'apprentissage,
mais plus tard ce temps est amorti notamment en accumulant plusieurs projets 
avec. Symfony ne doit en aucun cas être utilisé pour un site dépassant de peu
la simple vitrine, par contre il peut être utilisé si l'on sait que le site
à de grandes chances d'évoluer et de réaliser des traitements conséquents.\\
\textbf{Les points forts} de ce framework c'est qu'il permet de réaliser très 
facilement toutes les tâches récurrentes ce qui allège énormément le code.\\
Premièrement SF2 respecte le MVC permettant une meilleure lisibilité, 
extensibilité et réutilisabilité. 
L'arborescence de Symfony2 est composé de 4 répertoires,
\begin{enumerate}
\item app/ contenant les fichiers de configurations de base, donnant le chemins
aux fichiers de configurations à l'intérieur des bundles.

\item src/ les fichiers sources contenant les bundles, les bundles peuvent
être assimilé à des packages ou à des mini-projets indépendants mais pouvant
interagir.

\item vendor/ Ce répertoire contient les bundles de base plus ceux que vous
voudrez ajouter, attention seulement des bundles extérieurs car il existe
maintenant une communauté très forte autour de Symfony et des développeurs
laisse leur bundle à disposition (cf \url{http://knpbundles.com/}, donc on ne 
change pas le contenu de ces fichiers.

\item web/ Contient les seules fichiers accessibles aux visiteurs,
les fichiers nécessaire à tout site internet, css,js, les images ... \\
Il contient deux fichiers clés le contrôleur frontal (app.php) et celui
pour le mode dev (app_dev.php)
\end{enumerate}

SF2 est très attaché aux systèmes de namespaces de php, chaque namespace 
correspond au chemin du fichier.
SF2 fonctionne énormément avec des config, soit en .yml, xml, php ou 
annotations.
Par défaut la configuration de base de SF2 est en .yml, chaque bundle a son 
propre répertoire “config”, ainsi chacun pourra choisir sa configuration 
préférée, notamment pour les routes.
Personnellement je préfère les annotations pour les ORM(Object Relational 
Mapping  et le .yml pour le reste car plus lisible que le xml.
Le système de route de SF2, relie une url à un contrôleur exécutant une action 
et rendant une page html. Certes, cela pourrait plus pratique pour les 
développeurs de configurer les routes en annotations, cependant les projets 
web peuvent comprendre des webmasters et des designers ayant peu de compétence 
en programmation, et cela les obligeraient à lire tout le code du contrôleur 
pour lire les routes et savoir à quel fichier html.twig correspond cette url.
exemple de fichiers de route:

\begin{verbatim}
# app/config/routing.yml
blog_show:
    pattern:   /blog/{slug}
    defaults:  { _controller: AcmeBlogBundle:Blog:show }
\end{verbatim}
\begin{verbatim}
<!-- app/config/routing.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<routes xmlns="http://symfony.com/schema/routing"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://symfony.com/schema/routing http://symfony.com/schema/routing/routing-1.0.xsd">

    <route id="blog_show" pattern="/blog/{slug}">
        <default key="_controller">AcmeBlogBundle:Blog:show</default>
    </route>
</routes>
\end{verbatim}
Ceci illustre la différence entre le YAML et le XML
\begin{verbatim}
// app/config/routing.php
use Symfony\Component\Routing\RouteCollection;
use Symfony\Component\Routing\Route;

$collection = new RouteCollection();
$collection->add('blog_show', new Route('/blog/{slug}', array(
    '_controller' => 'AcmeBlogBundle:Blog:show',
)));

return $collection;
\end{verbatim}
L'avantage c'est que lors d'un projet Symfony, en se répartissant le travail,
chaque membre peut dans son propre bundle choisir ce qu'il préfère 
(annotations,YAML,XML ou php).
Un projet Symfony se construit grâce à des commandes dans un terminal,
les commandes sont de types : php app/console lacommande \\
exemple : \textit{php app/console generate:bundle} \\
à travers son nom l'on devine sa fonction, et ensuite il suffit de suivre
les instructions et Symfony demandera quelle type de configuration l'on 
souhaite (annotations,YAML,XML ou php). L'IDE NetBeans offre une interface
très pratique pour réaliser ces commandes, cela évite de retaper \\
"php app/console" et juste dessous est écrit le manuel de la commande. \\
Il y a même une commande pour générer ses entités. \\
Une entité comme il a été signalé avant c'est un objet qui va pouvoir
s'enregistrer ou se charger à partir d'une base de donnée, ainsi lors
d'un projet d'un Symfony la base n'est en aucun cas créée avec des commandes
sql ni avec une interface de gestion tel que phpmyadmin ou sqlyog par 
exemples. Voici en exemple une entité :
\begin{verbatim}
// src/Acme/StoreBundle/Entity/Product.php
namespace Acme\StoreBundle\Entity;

use Doctrine\ORM\Mapping as ORM;

/**
 * @ORM\Entity
 * @ORM\Table(name="product")
 */
class Product
{
/**
*annotations que Symfony interprétera
*
/
    /**
     * @ORM\Id
     * @ORM\Column(type="integer")
     * @ORM\GeneratedValue(strategy="AUTO")
     */
    protected $id;

    /**
     * @ORM\Column(type="string", length=100)
     */
    protected $name;

    /**
     * @ORM\Column(type="decimal", scale=2)
     */
    protected $price;

    /**
     * @ORM\Column(type="text")
     */
    protected $description;
}
\end{verbatim}
Juste après l'on exécute la commande \textit{doctrine:schema: --force} et
la table "product" sera créée. Il est aussi possible de rajouter des règles
de validations (là aussi pour les mêmes raisons je préfère en annotations).
\begin{verbatim}
 /**
     * @var string $titre
     *
     * @ORM\Column(name="titre", type="string", length=255)
     * @Assert\MinLength(10)
     */
    private $titre;
    
    /**
     * @var text $contenu
     *
     * @ORM\Column(name="contenu", type="text")
     * @Assert\NotBlank()
     */
    private $contenu;
    
    /**
     * @var string $auteur
     *
     * @ORM\Column(name="auteur", type="string", length=255)
     * @Assert\MinLength(2)
     */
    private $auteur;
    
    /**
     * @ORM\ManyToMany(targetEntity="Sdz\BlogBundle\Entity\Tag")
     * @Assert\Valid()
     */
    private $tags;
\end{verbatim}
Les annotations du type ManyToMany permettent de lier des entités entre elles,
au niveau base de donnée cela correspond à l'importation de clés étrangères
avec les contraintes qui y correspondent, le premier terme correspond à l'
entité où l'on se situe et le second donc le ToMany à l'entité cible.
Il est possible de créer ses propres règles. Cela évite la répétition
des conditions pour tester si la variable est bien présente avec la fonction
isset() plus d'autres règles (nombre positif, inférieur à 100...), lors de
la réception des données d'un formulaire. \\
Les formulaires sont Symfony sont des objets, les formulaires sont liés à
une entité et chaque champ du formulaire correspond à un attribut de l'entité,
évidemment certains attributs peuvent ne pas avoir de champs de formulaire 
leur correspondant. Par convention le nom d'un formulaire est 
"EntityNameType" exemple du site du zero:
\begin{verbatim}
<?php
// src/Sdz/BlogBundle/Form/ArticleType.php

namespace Sdz\BlogBundle\Form;

use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormBuilder;

class ArticleType extends AbstractType
{
    public function buildForm(FormBuilder $builder, array $options)
    {
	    $builder
            ->add('date')
            ->add('titre')
            ->add('contenu')
            ->add('auteur');
    }
}

\end{verbatim}
Le premier paramètre est le nom de l'attribut de l'entité correspondante,
en deuxième paramètre le type du champ( champ de texte, radio,case à 
cocher,...). Ici il n'y a que le premier paramètre, le deuxième Symfony le
choisit en fonction du type de l'attribut, cela prouve la puissance de ce 
framework car il utilise l'introspection, notion vu au semestre 7, consistant
à réaliser des traitements en fonction de la classe d'un objet, du nom de 
son attribut... \\ Il existe le type 'entity', par exemple
->add('user', 'entity'), détecter lors des relations (ManyToOne ...),
le champ retourner sera une liste déroulante contenant tout les instances
de cette entité, il est possible en rajoutant en paramètre une requête afin
de filtrer la liste. Symfony offre le CRUD (Create Update Delete), c'est une
commande qui prend en paramètre une entité et va générer les fichiers 
comprenant, le formulaire donc le EntityType.php, le contrôleur, les routes
en demandant au passage le format de configuration (xml,php...), et les 
fichiers de rendu en html.twig. Le CRUD génère l'index montrant toutes les
instances de l'entité, ainsi la page d'index montre tout le contenu de cette 
table, les pages edit et show prennent en paramètre un "id" (un entier)
et retourne une page correspondant à leur nom, edit permet d'effacer 
l'instance ou de la modifier, et une page permettant de créer de nouvelles 
instances. Le CRUD est un bon exemple pour montrer comment Symfony permet de
gagner du temps.
Dans le contrôleur d'une page gérant un formulaire, exemple :
\begin{verbatim}
public function ajouterAction()
{
    $article = new Article;
    $form = $this->createForm(new ArticleType, $article);

    $request = $this->get('request');
    if( $request->getMethod() == 'POST' )
    {
        $form->bindRequest($request);
        if( $form->isValid() )
        {
            $em = $this->getDoctrine()->getEntityManager();
            $em->persist($article);
            $em->flush();

            return $this->redirect( $this->generateUrl('sdzblog_accueil') );
        }
    }

    return $this->render('SdzBlogBundle:Blog:ajouter.html.twig', array(
        'form' => $form->createView(),
    ));
}
\end{verbatim}
Explication : l'EntityManager est un objet globale gérant les entités,
avec la méthode "bindRequest" l'entité '\$article' contient les données 
entrées dans le formulaire par l'utilisateur, la méthode du formulaire 
isValid() teste la présence ainsi que toutes les règles de validations qui ont
été indiqué à l'Entité @AssertMinLength(2). Tant que l'entité n'a pas été 
confronté à un validateur les attributs de l'objet peuvent ne pas respecter
ses propres règles, la méthode persist consiste à persister soit enregistrer
l'objet en base de donnée et flush réalise les transactions demandées, à
l'instar de l'app engine si l'une des transactions ne échoue aucune est 
exécutée.
\begin{verbatim}
return $this->render('SdzBlogBundle:Blog:ajouter.html.twig', array(
        'form' => $form->createView(),
\end{verbatim}
Ce bloc nous oriente vers une explication du moteur de template le TWIG.,
il est inspiré de celui des librairies Python JinJa et Django, leur syntaxe
est similaire. Le principe est d'offrir un code simple car en effet en 
développement web, il n'y a pas que des développeurs, il y a aussi des 
webmasters, le rôle du TWIG est d'éviter de surcharger le code html avec du 
php, le TWIG se veut être un langage simple, il est possible de créer ses 
propres macros, d'hériter d'une autre page, ceci est très pratique.
L'héritage permet de qu'à partir d'un fichier de base "base.html.twig" par 
exemple que toutes les pages qui en hériteront se retrouveront avec le code
html de la page, les pages filles surcharges des blocs de la page mère 
exemple:
\begin{verbatim}
{% extends base.html.twig %}
{% block content %}
  du contenu propre à cette page
  {%  endblock %}
\end{verbatim}
La page mère contient tout les contours du site, l'en-tête, le pied de page,
et imaginons que son block content soit vide et que sa position soit le milieu
de la page, la page fille sera similaire en tout point à la page mère, excepté
le milieu. Les fichiers de moteurs de templates peuvent recevoir des 
paramètre, de la manière suivante,
exemple de mon application :
\begin{verbatim}
return $this->render('TimeOffManagerBundle::show.html.twig', array(
        'entity' => $demandeconges,
\end{verbatim}
Le code de show.html.twig :
\begin{verbatim}
 {{entity.datedebut|date('d/m/Y')}}
\end{verbatim}
Ce code m'affichera la date contenu dans l'attribut datedebut au format
jour/mois/année, pour ça fonctionne l'attribut doit être publique ou avoir
un getter de ce type 'getDatedebut',le nom de l'attribut avec sa première
lettre en majuscule, et pour finir sur la puissance de Symfony notamment au
niveau de l’introspection. Il est à noter que toutes les caractéristiques 
citées du TWIG sont valables pour les moteurs de templates JinJa et Django.

\subsection{Difficultés rencontrées}
La principale difficulté fut le temps d'apprentissage du php et surtout
de Symfony, puis du javascript de son framework JQuery\up{\textbf{*}}, 
JQueryUi et de l'AJAX\up{\textbf{*}}, les deux derniers sont arrivés au fur
et à mesure de l'avancé, en effet ma méthode de travail était basée sur les
méthodes agiles, car je faisais une mise en point fréquemment avec mon
maître de stage, notamment un changement au niveau de mon formulaire pour
les demandes de congés, voici le widget de symfony pour le type "date" \\
\includegraphics[scale=1]{images/datetimewidget} \\
parfait pour enregistrer une date naissance par exemple mais pour les demandes
de congés ayant souvent lieu la même année, voir le même mois, le widget
"datepicker" de JQueryUI est préférable. \\
\includegraphics[scale=1]{images/datepicker}\\
Côté Symfony le seul changement est d'imposer le format de champ de texte,
->add('datedebut,'textfield') et ensuite il s'agit de JQuery classique.
Les problèmes posés été que ce widget permet de modifier le contenu d'un
champ de texte donc la donnée reçu était un string et un un Datetime, il a
suffit d'une conversion dans le contrôleur afin qu'il suffit d'effectuer
après la méthode bindrequest. Développer un gestionnaire de congés avait
pour avantage que les membres de la DSI étaient à la fois conseiller en tant
qu'expert mais aussi simple utilisateur. À la fin mon application était 
fonctionnelle, il ne manquait plus qu' à la mettre en production afin de
discuter des améliorations possibles, et l'aide d'un webmaster pour s'occuper
du design.
\newpage
\section{Conclusion}
À ce jour, au vu de l'implémentation que j'ai réalisé du gestionnaire de 
congés est fonctionnelle et rempli les objectifs, cependant elle n'a pas
pu  être mise en production encore moins tester par de simples utilisateurs.
Ceci s'explique par la situation de \textbf{Cortix}, en effet la liquidation
a été prononcé début août (cf \cite{finCortix}), compte-tenu de cela, je
remercie d'autant plus les membres du siège d'avoir répondu à mes question,
donc il y a un risque que mon application ne soit pas mise en production.
Toutefois le sujet du stage a été rempli, j'ai pu découvrir et évaluer les
Google App Engine. Ce stage en entreprise, qui se trouve être mon premier stage, m'a fait découvrir le monde du
travail, le fait d'être sous la responsabilité et sous les ordres de quelqu'un et de pouvoir discuter avec
cette personne afin de comprendre le problème et sa logique de résolution.
Ce stage m'a aussi permis de me rendre compte de l'évolution d'un projet en satisfaisant au fur et à
mesure les différentes nécessités du projet.Ce fut une expérience très enrichissante sur le plan professionnel, car j'étais entouré d'experts dans
leur domaine, et mes connaissances ainsi que ma compréhension se sont développées. Le sujet,
bien que difficile au début, me devint très rapidement passionnant.
Ayant travaillé seul bien qu'aidé par mes collègues lorsque bloqué, l'analyse du travail à effectuer
avait déjà principalement été faite par mon maître de stage, et il me donna donc surtout des
indications. Cependant, il ne manqua pas de me faire comprendre le pourquoi de la façon de
procéder, en me faisant expérimenter une certaine approche, et en me faisant comprendre ses
défauts. Lors du projet Symfony j’eus bénéficié de l'expertise de M.RASCAR,
tout comme mon maître de stage il m'a su me guider et m'éclaircir certains
points obscurs
Le fait d'avoir réalisé l'entièreté du projet de A à Z m'a aussi fait comprendre les limites et les
possibilités que l'on doit impérativement s'imposer lors d'un projet, et imposer au projet. De plus,travailler seul, à ma convenance pour mon organisation et mes recherches, ne m'a pas déplu, mais travailler en équipe
ne me déplaît pas pour autant.\\
Lors de ce stage, j'ai découver le domaine de la programmation web, j'en 
suis ravi car ce domaine complète ma formation étant le Génie Logiciel, en effet cette
formation comprend tout aussi le développement logiciel que le développement
web. Découvrir les Google App engine fut très enrichissant, cela m'a motivé
de continuer à suivre leur évolution.\\
En réalisant ce stage j’espérai le monde de l'Entreprise et du développement demanière professionnelle. La différence avec l'apprentissage théorique de l'université fut très plaisant, car il s'agissait ici d'un apprentissage pratique.
Je suis à présent d'autant plus passionné et intéressé dans la programmation et le développement
d'applications ainsi que dans la gestion du développement et des ressources.
Ce stage complète ma formation et confirme mon choix de spécialité.


\nocite{*}
\newpage
\section*{Glossaire et Lexique}
\begin{itemize}

\item \textbf{AJAX} : Asynchronous JavaScript and XML* (''XML* et Javascript asynchrones''). Langage
qui permet de récupérer des informations, et de les inclure sur une page, mais sans attendre le
résultat de la requête.

\item \textbf{Framework} : Ensemble de bibliothèques, d'outils et de conventions permettant le
développement d'applications.


\item \textbf{jQuery} : Framework* Javascript libre qui porte sur l'interaction entre JavaScript (comprenant
l'AJAX) et HTML, et a pour but de simplifier des commandes communes de Javascript, son slogan \og Write less, Do more\fg

\item \textbf{MVC}:Modèle-vue-contrôleur de l'anglais Model-View-Controller), tout comme les design pattern Modèle-vue-présentation ou Présentation, abstraction, contrôle, est un modèle destiné à répondre aux besoins des applications interactives en séparant les problématiques liées aux différents composants au sein de leur architecture respective.

Ce paradigme regroupe les fonctions nécessaires en trois catégories :
\begin{enumerate}
\item    un modèle (modèle de données),
\item    une vue (présentation, interface utilisateur)
\item     un contrôleur (logique de contrôle, gestion des événements, synchronisation)
\end{enumerate}

\item \textbf{XML} : (Extensible Markup Language ''langage extensible de balisage'') est un langage
informatique de balisage générique. Il sert essentiellement à stocker/transférer des données
de type texte.


\item \textbf{YAML}, acronyme récursif de Ain't Markup Language, est un format de représentation de données, son but est d'être plus lisible que le XML,
contrairement au XML qui peut s'écrire sur une seule ligne, l'indendation compte tout comme le langage de programmation Python.

\end{itemize}
\newpage
\appendix
\section{Les agences de Cortix}
\includegraphics[scale=1]{images/cortixEurope}

\section{Exemple de sites Cortix}
\subsection{\url{www.renovation-appartement-93.com}}
\includegraphics[scale=0.4]{images/renovation-appartement-93}
\subsection{\url{www.renovation-jmh-27.com}}
\includegraphics[scale=0.4]{images/renovation-jmh-27}

\section{GAE DashBoard}
\includegraphics[scale=0.5]{images/GAEDashboard}
\newpage


\bibliography{bibliographie}
\end{document}